// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_MAC_FOUNDATION_UTIL_H_
#define BASE_MAC_FOUNDATION_UTIL_H_

#include <CoreFoundation/CoreFoundation.h>

#include <string>
#include <vector>

#include "base/base_export.h"
#include "base/logging.h"
#include "base/mac/scoped_cftyperef.h"
#include "build/build_config.h"

#if defined(__OBJC__)
#import <Foundation/Foundation.h>
@class NSFont;
@class UIFont;
#else // __OBJC__
#include <CoreFoundation/CoreFoundation.h>
class NSBundle;
class NSFont;
class NSString;
class UIFont;
#endif // __OBJC__

#if defined(OS_IOS)
#include <CoreText/CoreText.h>
#else
#include <ApplicationServices/ApplicationServices.h>
#endif

// Adapted from NSObjCRuntime.h NS_ENUM definition (used in Foundation starting
// with the OS X 10.8 SDK and the iOS 6.0 SDK).
#if __has_extension(cxx_strong_enums) && (defined(OS_IOS) || (defined(MAC_OS_X_VERSION_10_8) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_8))
#define CR_FORWARD_ENUM(_type, _name) enum _name : _type _name
#else
#define CR_FORWARD_ENUM(_type, _name) _type _name
#endif

// Adapted from NSPathUtilities.h and NSObjCRuntime.h.
#if __LP64__ || NS_BUILD_32_LIKE_64
typedef CR_FORWARD_ENUM(unsigned long, NSSearchPathDirectory);
typedef unsigned long NSSearchPathDomainMask;
#else
typedef CR_FORWARD_ENUM(unsigned int, NSSearchPathDirectory);
typedef unsigned int NSSearchPathDomainMask;
#endif

typedef struct OpaqueSecTrustRef* SecACLRef;
typedef struct OpaqueSecTrustedApplicationRef* SecTrustedApplicationRef;

namespace base {

class FilePath;

namespace mac {

    // Returns true if the application is running from a bundle
    BASE_EXPORT bool AmIBundled();
    BASE_EXPORT void SetOverrideAmIBundled(bool value);

#if defined(UNIT_TEST)
    // This is required because instantiating some tests requires checking the
    // directory structure, which sets the AmIBundled cache state. Individual tests
    // may or may not be bundled, and this would trip them up if the cache weren't
    // cleared. This should not be called from individual tests, just from test
    // instantiation code that gets a path from PathService.
    BASE_EXPORT void ClearAmIBundledCache();
#endif

    // Returns true if this process is marked as a "Background only process".
    BASE_EXPORT bool IsBackgroundOnlyProcess();

    // Returns the path to a resource within the framework bundle.
    BASE_EXPORT FilePath PathForFrameworkBundleResource(CFStringRef resourceName);

    // Returns the creator code associated with the CFBundleRef at bundle.
    OSType CreatorCodeForCFBundleRef(CFBundleRef bundle);

    // Returns the creator code associated with this application, by calling
    // CreatorCodeForCFBundleRef for the application's main bundle.  If this
    // information cannot be determined, returns kUnknownType ('????').  This
    // does not respect the override app bundle because it's based on CFBundle
    // instead of NSBundle, and because callers probably don't want the override
    // app bundle's creator code anyway.
    BASE_EXPORT OSType CreatorCodeForApplication();

    // Searches for directories for the given key in only the given |domain_mask|.
    // If found, fills result (which must always be non-NULL) with the
    // first found directory and returns true.  Otherwise, returns false.
    BASE_EXPORT bool GetSearchPathDirectory(NSSearchPathDirectory directory,
        NSSearchPathDomainMask domain_mask,
        FilePath* result);

    // Searches for directories for the given key in only the local domain.
    // If found, fills result (which must always be non-NULL) with the
    // first found directory and returns true.  Otherwise, returns false.
    BASE_EXPORT bool GetLocalDirectory(NSSearchPathDirectory directory,
        FilePath* result);

    // Searches for directories for the given key in only the user domain.
    // If found, fills result (which must always be non-NULL) with the
    // first found directory and returns true.  Otherwise, returns false.
    BASE_EXPORT bool GetUserDirectory(NSSearchPathDirectory directory,
        FilePath* result);

    // Returns the ~/Library directory.
    BASE_EXPORT FilePath GetUserLibraryPath();

    // Takes a path to an (executable) binary and tries to provide the path to an
    // application bundle containing it. It takes the outermost bundle that it can
    // find (so for "/Foo/Bar.app/.../Baz.app/..." it produces "/Foo/Bar.app").
    //   |exec_name| - path to the binary
    //   returns - path to the application bundle, or empty on error
    BASE_EXPORT FilePath GetAppBundlePath(const FilePath& exec_name);

#define TYPE_NAME_FOR_CF_TYPE_DECL(TypeCF) \
    BASE_EXPORT std::string TypeNameForCFType(TypeCF##Ref);

    TYPE_NAME_FOR_CF_TYPE_DECL(CFArray);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFBag);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFBoolean);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFData);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFDate);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFDictionary);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFNull);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFNumber);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFSet);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFString);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFURL);
    TYPE_NAME_FOR_CF_TYPE_DECL(CFUUID);

    TYPE_NAME_FOR_CF_TYPE_DECL(CGColor);

    TYPE_NAME_FOR_CF_TYPE_DECL(CTFont);
    TYPE_NAME_FOR_CF_TYPE_DECL(CTRun);

#undef TYPE_NAME_FOR_CF_TYPE_DECL

    // Retain/release calls for memory management in C++.
    BASE_EXPORT void NSObjectRetain(void* obj);
    BASE_EXPORT void NSObjectRelease(void* obj);

    // CFTypeRefToNSObjectAutorelease transfers ownership of a Core Foundation
    // object (one derived from CFTypeRef) to the Foundation memory management
    // system.  In a traditional managed-memory environment, cf_object is
    // autoreleased and returned as an NSObject.  In a garbage-collected
    // environment, cf_object is marked as eligible for garbage collection.
    //
    // This function should only be used to convert a concrete CFTypeRef type to
    // its equivalent "toll-free bridged" NSObject subclass, for example,
    // converting a CFStringRef to NSString.
    //
    // By calling this function, callers relinquish any ownership claim to
    // cf_object.  In a managed-memory environment, the object's ownership will be
    // managed by the innermost NSAutoreleasePool, so after this function returns,
    // callers should not assume that cf_object is valid any longer than the
    // returned NSObject.
    //
    // Returns an id, typed here for C++'s sake as a void*.
    BASE_EXPORT void* CFTypeRefToNSObjectAutorelease(CFTypeRef cf_object);

    // Returns the base bundle ID, which can be set by SetBaseBundleID but
    // defaults to a reasonable string. This never returns NULL. BaseBundleID
    // returns a pointer to static storage that must not be freed.
    BASE_EXPORT const char* BaseBundleID();

    // Sets the base bundle ID to override the default. The implementation will
    // make its own copy of new_base_bundle_id.
    BASE_EXPORT void SetBaseBundleID(const char* new_base_bundle_id);

} // namespace mac
} // namespace base

#if !defined(__OBJC__)
#define OBJC_CPP_CLASS_DECL(x) class x;
#else // __OBJC__
#define OBJC_CPP_CLASS_DECL(x)
#endif // __OBJC__

// Convert toll-free bridged CFTypes to NSTypes and vice-versa. This does not
// autorelease |cf_val|. This is useful for the case where there is a CFType in
// a call that expects an NSType and the compiler is complaining about const
// casting problems.
// The calls are used like this:
// NSString *foo = CFToNSCast(CFSTR("Hello"));
// CFStringRef foo2 = NSToCFCast(@"Hello");
// The macro magic below is to enforce safe casting. It could possibly have
// been done using template function specialization, but template function
// specialization doesn't always work intuitively,
// (http://www.gotw.ca/publications/mill17.htm) so the trusty combination
// of macros and function overloading is used instead.

#define CF_TO_NS_CAST_DECL(TypeCF, TypeNS)                      \
    OBJC_CPP_CLASS_DECL(TypeNS)                                 \
                                                                \
    namespace base {                                            \
        namespace mac {                                         \
            BASE_EXPORT TypeNS* CFToNSCast(TypeCF##Ref cf_val); \
            BASE_EXPORT TypeCF##Ref NSToCFCast(TypeNS* ns_val); \
        }                                                       \
    }

#define CF_TO_NS_MUTABLE_CAST_DECL(name)                                          \
    CF_TO_NS_CAST_DECL(CF##name, NS##name)                                        \
    OBJC_CPP_CLASS_DECL(NSMutable##name)                                          \
                                                                                  \
    namespace base {                                                              \
        namespace mac {                                                           \
            BASE_EXPORT NSMutable##name* CFToNSCast(CFMutable##name##Ref cf_val); \
            BASE_EXPORT CFMutable##name##Ref NSToCFCast(NSMutable##name* ns_val); \
        }                                                                         \
    }

// List of toll-free bridged types taken from:
// http://www.cocoadev.com/index.pl?TollFreeBridged

CF_TO_NS_MUTABLE_CAST_DECL(Array);
CF_TO_NS_MUTABLE_CAST_DECL(AttributedString);
CF_TO_NS_CAST_DECL(CFCalendar, NSCalendar);
CF_TO_NS_MUTABLE_CAST_DECL(CharacterSet);
CF_TO_NS_MUTABLE_CAST_DECL(Data);
CF_TO_NS_CAST_DECL(CFDate, NSDate);
CF_TO_NS_MUTABLE_CAST_DECL(Dictionary);
CF_TO_NS_CAST_DECL(CFError, NSError);
CF_TO_NS_CAST_DECL(CFLocale, NSLocale);
CF_TO_NS_CAST_DECL(CFNumber, NSNumber);
CF_TO_NS_CAST_DECL(CFRunLoopTimer, NSTimer);
CF_TO_NS_CAST_DECL(CFTimeZone, NSTimeZone);
CF_TO_NS_MUTABLE_CAST_DECL(Set);
CF_TO_NS_CAST_DECL(CFReadStream, NSInputStream);
CF_TO_NS_CAST_DECL(CFWriteStream, NSOutputStream);
CF_TO_NS_MUTABLE_CAST_DECL(String);
CF_TO_NS_CAST_DECL(CFURL, NSURL);

#if defined(OS_IOS)
CF_TO_NS_CAST_DECL(CTFont, UIFont);
#else
CF_TO_NS_CAST_DECL(CTFont, NSFont);
#endif

#undef CF_TO_NS_CAST_DECL
#undef CF_TO_NS_MUTABLE_CAST_DECL
#undef OBJC_CPP_CLASS_DECL

namespace base {
namespace mac {

    // CFCast<>() and CFCastStrict<>() cast a basic CFTypeRef to a more
    // specific CoreFoundation type. The compatibility of the passed
    // object is found by comparing its opaque type against the
    // requested type identifier. If the supplied object is not
    // compatible with the requested return type, CFCast<>() returns
    // NULL and CFCastStrict<>() will DCHECK. Providing a NULL pointer
    // to either variant results in NULL being returned without
    // triggering any DCHECK.
    //
    // Example usage:
    // CFNumberRef some_number = base::mac::CFCast<CFNumberRef>(
    //     CFArrayGetValueAtIndex(array, index));
    //
    // CFTypeRef hello = CFSTR("hello world");
    // CFStringRef some_string = base::mac::CFCastStrict<CFStringRef>(hello);

    template <typename T>
    T CFCast(const CFTypeRef& cf_val);

    template <typename T>
    T CFCastStrict(const CFTypeRef& cf_val);

#define CF_CAST_DECL(TypeCF)                      \
    template <>                                   \
    BASE_EXPORT TypeCF##Ref                       \
    CFCast<TypeCF##Ref>(const CFTypeRef& cf_val); \
                                                  \
    template <>                                   \
    BASE_EXPORT TypeCF##Ref                       \
    CFCastStrict<TypeCF##Ref>(const CFTypeRef& cf_val);

    CF_CAST_DECL(CFArray);
    CF_CAST_DECL(CFBag);
    CF_CAST_DECL(CFBoolean);
    CF_CAST_DECL(CFData);
    CF_CAST_DECL(CFDate);
    CF_CAST_DECL(CFDictionary);
    CF_CAST_DECL(CFNull);
    CF_CAST_DECL(CFNumber);
    CF_CAST_DECL(CFSet);
    CF_CAST_DECL(CFString);
    CF_CAST_DECL(CFURL);
    CF_CAST_DECL(CFUUID);

    CF_CAST_DECL(CGColor);

    CF_CAST_DECL(CTFont);
    CF_CAST_DECL(CTFontDescriptor);
    CF_CAST_DECL(CTRun);

    CF_CAST_DECL(SecACL);
    CF_CAST_DECL(SecTrustedApplication);

#undef CF_CAST_DECL

#if defined(__OBJC__)

    // ObjCCast<>() and ObjCCastStrict<>() cast a basic id to a more
    // specific (NSObject-derived) type. The compatibility of the passed
    // object is found by checking if it's a kind of the requested type
    // identifier. If the supplied object is not compatible with the
    // requested return type, ObjCCast<>() returns nil and
    // ObjCCastStrict<>() will DCHECK. Providing a nil pointer to either
    // variant results in nil being returned without triggering any DCHECK.
    //
    // The strict variant is useful when retrieving a value from a
    // collection which only has values of a specific type, e.g. an
    // NSArray of NSStrings. The non-strict variant is useful when
    // retrieving values from data that you can't fully control. For
    // example, a plist read from disk may be beyond your exclusive
    // control, so you'd only want to check that the values you retrieve
    // from it are of the expected types, but not crash if they're not.
    //
    // Example usage:
    // NSString* version = base::mac::ObjCCast<NSString>(
    //     [bundle objectForInfoDictionaryKey:@"CFBundleShortVersionString"]);
    //
    // NSString* str = base::mac::ObjCCastStrict<NSString>(
    //     [ns_arr_of_ns_strs objectAtIndex:0]);
    template <typename T>
    T* ObjCCast(id objc_val)
    {
        if ([objc_val isKindOfClass:[T class]]) {
            return reinterpret_cast<T*>(objc_val);
        }
        return nil;
    }

    template <typename T>
    T* ObjCCastStrict(id objc_val)
    {
        T* rv = ObjCCast<T>(objc_val);
        DCHECK(objc_val == nil || rv);
        return rv;
    }

#endif // defined(__OBJC__)

    // Helper function for GetValueFromDictionary to create the error message
    // that appears when a type mismatch is encountered.
    BASE_EXPORT std::string GetValueFromDictionaryErrorMessage(
        CFStringRef key, const std::string& expected_type, CFTypeRef value);

    // Utility function to pull out a value from a dictionary, check its type, and
    // return it. Returns NULL if the key is not present or of the wrong type.
    template <typename T>
    T GetValueFromDictionary(CFDictionaryRef dict, CFStringRef key)
    {
        CFTypeRef value = CFDictionaryGetValue(dict, key);
        T value_specific = CFCast<T>(value);

        if (value && !value_specific) {
            std::string expected_type = TypeNameForCFType(value_specific);
            DLOG(WARNING) << GetValueFromDictionaryErrorMessage(key,
                expected_type,
                value);
        }

        return value_specific;
    }

    // Converts |path| to an autoreleased NSString. Returns nil if |path| is empty.
    BASE_EXPORT NSString* FilePathToNSString(const FilePath& path);

    // Converts |str| to a FilePath. Returns an empty path if |str| is nil.
    BASE_EXPORT FilePath NSStringToFilePath(NSString* str);

#if defined(__OBJC__)
    // Converts |range| to an NSRange, returning the new range in |range_out|.
    // Returns true if conversion was successful, false if the values of |range|
    // could not be converted to NSUIntegers.
    BASE_EXPORT bool CFRangeToNSRange(CFRange range,
        NSRange* range_out) WARN_UNUSED_RESULT;
#endif // defined(__OBJC__)

} // namespace mac
} // namespace base

// Stream operations for CFTypes. They can be used with NSTypes as well
// by using the NSToCFCast methods above.
// e.g. LOG(INFO) << base::mac::NSToCFCast(@"foo");
// Operator << can not be overloaded for ObjectiveC types as the compiler
// can not distinguish between overloads for id with overloads for void*.
BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
    const CFErrorRef err);
BASE_EXPORT extern std::ostream& operator<<(std::ostream& o,
    const CFStringRef str);

#endif // BASE_MAC_FOUNDATION_UTIL_H_
